﻿using System;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Data;
using System.IO;
using System.Linq;
using System.Web.Mvc;
namespace QuocHoi_TV_Frontend.Models
{
    public class Util
    {
        #region ATTRIBUTE
        public const byte        NULL_BYTE       = byte.MinValue;
        public const short       NULL_SHORT      = short.MinValue;
        public const int         NULL_INT        = int.MinValue;
        public const long        NULL_LONG       = long.MinValue;
        public const decimal     NULL_DECIMAL    = decimal.MinValue;
        public const float       NULL_FLOAT      = float.NaN;
        public const double      NULL_DOUBLE     = double.NaN;
        public const Single      NULL_SINGLE     = Single.NaN;
        public static DateTime   NULL_DATETIME   = DateTime.MinValue;
        public static Guid       NULL_GUID       = Guid.Empty;
        public static string     NULL_STRING     = string.Empty;
        #endregion

        #region CONSTRUCTOR
        static Util() { }
        #endregion

        #region NULL OBJECT METHODS
        /// <summary>
        /// Trả về giá trị được coi là null của objectToGet (nếu thuộc kiểu không null như int, float thì trả về MinValue)
        /// </summary>
        public static object GetNullOf(object objectToGet)
        {
            if (objectToGet == null) return null;
            if (objectToGet == DBNull.Value) return objectToGet;
            if (objectToGet is DBNull) return DBNull.Value;
            if (objectToGet is bool) return false;
            if (objectToGet is short) return short.MinValue;
            if (objectToGet is int) return int.MinValue;
            if (objectToGet is long) return long.MinValue;
            if (objectToGet is decimal) return decimal.MinValue;
            if (objectToGet is DateTime) return DateTime.MinValue;
            if (objectToGet is double) return double.NaN;
            if (objectToGet is float) return float.NaN;
            if (objectToGet is Single) return Single.NaN;
            if (objectToGet is string) return string.Empty;
            if (objectToGet is Guid) return Guid.Empty;
            return null;
        }

        /// <summary>
        /// Kiểm tra xem obj có phải null không (nếu thuộc kiểu không null như int, float thì kiểm tra xem có phải MinValue không)
        /// </summary>
        public static bool IsNull(object obj)
        {
            if (obj != null) return obj.Equals(Util.GetNullOf(obj));
            return true;
        }

        /// <summary>
        /// Kiểm tra xem objectToSet có phải null không, nếu null thì gán giá trị value cho nó (nếu thuộc kiểu không null như int, float thì kiểm tra xem có phải MinValue không)
        /// </summary>
        public static object ReplaceNullTo(object objectToSet, object value)
        {
            object o = objectToSet;
            if (Util.IsNull(objectToSet)) return value;
            return o;
        }
        
        /// <param name="isExactlyNull">Nếu để là true thì chỉ kiểm tra objectToSet có là null không nếu thuộc kiểu không null như int, float sẽ không kiểm tra</param>
        public static object ReplaceNullTo(object objectToSet, object value, bool isExactlyNull)
        {
            if ((isExactlyNull) && (objectToSet == null)) objectToSet = value;
            else if (Util.IsNull(objectToSet)) objectToSet = value;
            return objectToSet;
        }

        public static void SetToNull(ref object objectToSet)
        {
            objectToSet = Util.GetNullOf(objectToSet);
        }

        /// <summary>
        /// Kiểm tra xem obj có phải là giá trị DBNull hoặc null không
        /// </summary>
        public static bool IsDBNull(object obj)
        {
            if (obj != null) return (obj == DBNull.Value);
            return false;
        }

        /// <summary>
        /// Kiểm tra xem objectToSet có phải DBNull không, nếu null thì gán giá trị value cho nó
        /// </summary>
        public static object ReplaceDBNullTo(object objectToSet, object value)
        {
            object o = objectToSet;
            if (Util.IsDBNull(objectToSet)) o = value;
            return o;
        }
        #endregion

        #region SPELL NUMBER

        public void docso(TextBox txtTextBox, Label lblLabel)
        {
            string s = txtTextBox.Text.Trim();
            if (s != "")
            {
                s = xoasokhong(s);
                switch (s.Length)
                {
                    case 1: lblLabel.Text = motso(s) + " đồng"; break;
                    case 2: lblLabel.Text = haiso(s) + " đồng"; break;
                    case 3: lblLabel.Text = baso(s) + " đồng"; break;
                    default: lblLabel.Text = nhieuso(s, s.Length); break;
                }
            }
            else lblLabel.Text = "Bạn phải nhập giá trị vào";
        }

        #region Number function
        public string motso(string bienso)
        {
            switch (bienso)
            {
                case "0": return "không";
                case "1": return "một";
                case "2": return "hai";
                case "3": return "ba";
                case "4": return "bốn";
                case "5": return "năm";
                case "6": return "sáu";
                case "7": return "bảy";
                case "8": return "tám";
                case "9": return "chín";
            }
            return "không";
        }
        public string haiso(string bienso)
        {
            string biendoc = " mười ";
            if ((bienso.Substring(1, 1) == "0") && (bienso.Substring(0, 1) != "1")) biendoc = motso(bienso.Substring(0, 1)) + " mươi ";
            if (bienso.Substring(1, 1) != "0")
                switch (bienso.Substring(1, 1))
                {
                    case "5":
                        if (bienso.Substring(0, 1) == "1") biendoc = " mười lăm";
                        else biendoc = motso(bienso.Substring(0, 1)) + " mươi lăm";
                        break;
                    case "1":
                        if (bienso.Substring(0, 1) == "1") biendoc = " mười một";
                        else biendoc = motso(bienso.Substring(0, 1)) + " mươi mốt";
                        break;
                    default:
                        if (bienso.Substring(0, 1) == "1") biendoc = " mười " + motso(bienso.Substring(1, 1));
                        else biendoc = motso(bienso.Substring(0, 1)) + " mươi " + motso(bienso.Substring(1, 1));
                        break;
                }

            return biendoc;
        }
        public string baso(string bienso)
        {
            string biendoc = "trăm";
            if (bienso.Substring(1, 1) == "0")
            {
                if (bienso.Substring(2, 1) == "0") biendoc = motso(bienso.Substring(0, 1)) + " trăm ";
                else biendoc = motso(bienso.Substring(0, 1)) + " trăm lẻ " + motso(bienso.Substring(2, 1));
            }
            else
            {
                biendoc = motso(bienso.Substring(0, 1)) + " trăm " + haiso(bienso.Substring(1, 2));
            }
            return biendoc;
        }
        #endregion

        // Process 0 number
        private string xoasokhong(string tam)
        {
            while (tam[0] == '0')
            {
                if (tam.Length > 1) tam = tam.Substring(1, tam.Length - 1);
                else break;
            }
            return tam;
        }
        // Insert value
        private string kieuchen(int tam)
        {
            switch (tam)
            {
                case 0: return " đồng ";
                case 1: return " nghìn ";
                case 2: return " triệu ";
                case 3: return " tỷ ";
            }
            return "";
        }
        // Read multi number
        private string nhieuso(string bienso, int dodai)
        {
            string biendoc = "", bientam = "";
            int i = 0;
            while ((dodai) > 3)
            {

                bientam = baso(bienso.Substring(bienso.Length - 3, 3));
                bienso = bienso.Substring(0, bienso.Length - 3);
                biendoc = bientam + kieuchen(i) + biendoc;
                i++;
                if (i > 3) i = 1;
                if (dodai > 3) dodai = dodai - 3;
            }
            if (dodai == 1) biendoc = motso(bienso) + kieuchen(i) + biendoc;
            if (dodai == 2) biendoc = haiso(bienso) + kieuchen(i) + biendoc;
            if (dodai == 3) biendoc = baso(bienso) + kieuchen(i) + biendoc;
            return biendoc;
        }

        #endregion

        #region STRING METHODS
        /// <summary>
        /// Cắt lấy một đoạn trong chuỗi theo các giá trị truyền vào, nếu null hoặc giá trị để cắt không phù hợp sẽ trả về giá trị chuỗi rỗng
        /// </summary>
        public static string CutString(string source, int start, int length)
        {
            if ((source == null) || (source.Length < start) || (source.Length<1)) return "";
            if ((source.Length > start) && (source.Length - start < length)) return source.Substring(start);
            return source.Substring(start, length);
        }

        public static string CutString(string source, int start, int end, string appendedText)
        {
            return Util.CutString(source, start, end - start + 1) + appendedText;
        }

        /// <summary>
        /// Cắt một chuỗi theo số từ cho trước
        /// </summary>
        public static string CutStringByWord(string source, int wordLength)
        {
            return Util.CutStringByWord(source, wordLength, null);
        }

        public static string CutStringByWord(string source, int wordLength, string appendedText)
        {
            if (source == null) return "";
            string appended = appendedText == null ? "" : appendedText;
            MatchCollection mc = Regex.Matches(source, @"\w*");

            int i = 0;
            foreach (Match m in mc)
            {
                i += 1;
                if (i == wordLength) return Util.CutString(source, 0, m.Index + m.Value.Length) + appended;
            }
            return source + appended;
        }

        /// <summary>
        /// Kiểm tra xem chuỗi truyền vào có phải là 1 số hay không
        /// </summary>
        /// 
        public static string FormatNumber(string source)
        {
            try
            {
                CultureInfo c = CultureInfo.GetCultureInfo("vi");
                long temp = long.Parse(source);
                string str = temp.ToString("#,##", CultureInfo.InvariantCulture);        // "1.5"
                return str;
            }
            catch (Exception)
            {
                return "";
            }
        }
        public static bool IsNumber(string source)
        {
            if (!string.IsNullOrEmpty(source))
            {
                if (source.IndexOf("-") == 0) source.Remove(0, 1);

                char[] cs = source.ToCharArray();
                foreach (char c in cs)
                {
                    if (!char.IsDigit(c)) return false;
                }
                return true;
            }
            return false;
        }

        /// <summary>
        /// Kiểm tra một chuỗi xem có phải là số nguyên hoặc số thập phân hay không (có thể định nghĩa dấu thập phân)
        /// </summary>
        public static bool IsDecimalNumber(string source)
        {
            if (!string.IsNullOrEmpty(source))
            {
                if (source.IndexOf("-") == 0) source.Remove(0, 1);
                if (source.IndexOf(".") > 0) source.Remove(source.IndexOf("."), 1);

                char[] cs = source.ToCharArray();
                foreach (char c in cs)
                {
                    if (!char.IsDigit(c)) return false;
                }
                return true;
            }
            return false;
        }

        public static bool IsDecimalNumber(string source, string decimalPoint)
        {
            if (!string.IsNullOrEmpty(source))
            {
                if (source.IndexOf("-") == 0) source.Remove(0, 1);
                if (source.IndexOf(decimalPoint) != 0) source.Remove(source.IndexOf(decimalPoint), decimalPoint.Length);

                char[] cs = source.ToCharArray();
                foreach (char c in cs)
                {
                    if (!char.IsDigit(c)) return false;
                }
                return true;
            }
            return false;
        }

        /// <summary>
        /// Chuyển một chuỗi thành kiểu số nguyên int sau khi đã kiểm tra
        /// </summary>
        public static int ToInteger(string source)
        {
            if (Util.IsNumber(source))
            {
                try
                {
                    return int.Parse(source);
                }
                catch { }
            }
            return int.MinValue;
        }

        /// <summary>
        /// Chuyển một số thành kiểu số nguyên long sau khi đã kiểm tra
        /// </summary>
        public static long ToLong(string source)
        {
            if (Util.IsNumber(source))
            {
                try
                {
                    return long.Parse(source);
                }
                catch { }
            }
            return long.MinValue;
        }

        /// <summary>
        /// Chuyển một chuổi thành kiểu số cho trước sau khi đã kiểm tra
        /// </summary>
        public static object ToNumber(string source, string numberType)
        {
            if (Util.IsDecimalNumber(source))
            {
                try
                {
                    switch (numberType.ToLower())
                    {
                        case "byte":
                            return Convert.ToByte(source);

                        case "sbyte":
                            return Convert.ToSByte(source);

                        case "short":
                        case "int16":
                            return Convert.ToInt16(source);

                        case "ushort":
                        case "uint16":
                            return Convert.ToUInt16(source);

                        case "int":
                        case "int32":
                            return Convert.ToInt32(source);

                        case "uint":
                        case "uint32":
                            return Convert.ToUInt32(source);

                        case "long":
                        case "int64":
                            return Convert.ToInt64(source);

                        case "ulong":
                        case "uint64":
                            return Convert.ToUInt64(source);

                        case "decimal":
                            return Convert.ToDecimal(source);

                        case "double":
                            return Convert.ToDouble(source);

                        case "Single":
                            return Convert.ToSingle(source);
                    }
                }
                catch { }
            }
            return null;
        }

        public static object ToNumber(string source, Type numberType)
        {
            return Util.ToNumber(source, numberType.Name);
        }

        public static object ToNumber(string source, Type numberType, string decimalPoint)
        {
            if (Util.IsDecimalNumber(source, decimalPoint))
            {
                if (source.IndexOf(decimalPoint) != 0) source.Replace(decimalPoint, ".");

                return Util.ToNumber(source, numberType);
            }
            return null;
        }
        #endregion

        #region SECURITY METHODS
        /// <summary>
        /// Mã hóa theo thuật toán MD5 (1 chuỗi hoặc một mảng byte)
        /// </summary>
        public static string MD5Encrypt(string source)
        {
            if (Util.IsNull(source)) return "";

            byte[] clearBytes = Encoding.Unicode.GetBytes(source);
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            byte[] hashBytes = md5.ComputeHash(clearBytes);

            return BitConverter.ToString(hashBytes);
        }

        public static byte[] MD5Encrypt(byte[] source)
        {
            if (Util.IsNull(source)) return null;
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            byte[] hashBytes = md5.ComputeHash(source);
            return hashBytes;
        }

        /// <summary>
        /// Mã hóa theo thuật toán SHA1 (1 chuỗi hoặc một mảng byte)
        /// </summary>
        public static string SHA1Encrypt(string source)
        {
            if (Util.IsNull(source)) return "";

            byte[] clearBytes = Encoding.Unicode.GetBytes(source);
            SHA1Managed sha1 = new SHA1Managed();
            byte[] hashBytes = sha1.ComputeHash(clearBytes);

            return BitConverter.ToString(hashBytes);
        }

        public static byte[] SHA1Encrypt(byte[] source)
        {
            if (Util.IsNull(source)) return null;
            SHA1Managed sha1 = new SHA1Managed();
            byte[] hashBytes = sha1.ComputeHash(source);
            return hashBytes;
        }

        /// <summary>
        /// Mã hóa theo thuật toán cho trước (1 chuỗi hoặc một mảng byte)
        /// </summary>
        public static string Encypt(string source, string cryptoName)
        {
            if (Util.IsNull(source)) return "";
            byte[] clearBytes = Encoding.Unicode.GetBytes(source);
            HashAlgorithm hash = (HashAlgorithm)CryptoConfig.CreateFromName(cryptoName);
            byte[] hashBytes = hash.ComputeHash(clearBytes);

            return BitConverter.ToString(hashBytes);
        }

        public static byte[] Encrypt(byte[] source, string cryptoName)
        {
            if (Util.IsNull(source)) return null;
            HashAlgorithm hash = (HashAlgorithm)CryptoConfig.CreateFromName(cryptoName);
            byte[] hashBytes = hash.ComputeHash(source);
            return hashBytes;
        }
        #endregion

     

        static public string ConvertSortDirectionToSql(SortDirection sortDirection)
        {
            string LabsortDirection = String.Empty;
            switch (sortDirection)
            {
                case SortDirection.Ascending:
                    LabsortDirection = "ASC";
                    break;
                case SortDirection.Descending:
                    LabsortDirection = "DESC";
                    break;
            }
            return LabsortDirection;
        }
        static public string RemoveUnicode(string inputText)
        {
            string stFormD = inputText.Normalize(System.Text.NormalizationForm.FormD);
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            string str = "";
            for (int i = 0; i <= stFormD.Length - 1; i++)
            {
                UnicodeCategory uc = CharUnicodeInfo.GetUnicodeCategory(stFormD[i]);
                if (uc == UnicodeCategory.NonSpacingMark == false)
                {
                    if (stFormD[i] == 'd')
                        str = "d";
                    else if (stFormD[i] == 'Ð')
                        str = "D";
                    else if (stFormD[i] == '\r' | stFormD[i] == '\n')
                        str = "";
                    else
                        str = stFormD[i].ToString();
                    sb.Append(str);
                }
            }
            return sb.ToString();
        }
        static public string GetSortClause(string sortExpression, SortDirection sortDirection)
        {
            return sortExpression + " " + ConvertSortDirectionToSql(sortDirection);
        }
        static public string LastindexCus(string str, char cSearch, int num)
        {
            try
            {
                string strLast = "";
                for (int i = 0; i < num; i++)
                {
                    int lstIdx = str.LastIndexOf(" ");
                    strLast = str.Substring(lstIdx + 1, str.Length - lstIdx - 1) + " " + strLast;
                    str = str.Substring(0, lstIdx);
                }

                return strLast.Trim();
            }
            catch (Exception)
            {
                
                throw;
            }
        }
        private static readonly string[] VietNamChar = new string[] 
            { 
                "aAeEoOuUiIdDyY", 
                "áàạảãâấầậẩẫăắằặẳẵ", 
                "ÁÀẠẢÃÂẤẦẬẨẪĂẮẰẶẲẴ", 
                "éèẹẻẽêếềệểễ", 
                "ÉÈẸẺẼÊẾỀỆỂỄ", 
                "óòọỏõôốồộổỗơớờợởỡ", 
                "ÓÒỌỎÕÔỐỒỘỔỖƠỚỜỢỞỠ", 
                "úùụủũưứừựửữ", 
                "ÚÙỤỦŨƯỨỪỰỬỮ", 
                "íìịỉĩ", 
                "ÍÌỊỈĨ", 
                "đ", 
                "Đ", 
                "ýỳỵỷỹ", 
                "ÝỲỴỶỸ" 
            };
        public static string RemoveSign4VietnameseString(string str)
        {
            //Tiến hành thay thế , lọc bỏ dấu cho chuỗi

            for (int i = 1; i < VietNamChar.Length; i++)
            {

                for (int j = 0; j < VietNamChar[i].Length; j++)

                    str = str.Replace(VietNamChar[i][j], VietNamChar[0][i - 1]);

            }
            string[] ex = new string[] { "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "/", "?", ",", ".", ";", "'", "]", "[", ":", " ", "'" };
            for (int i = 0; i < ex.Length; i++)
            {
                str = str.Replace(ex[i], "-");
            }
            str = str.Replace("--", "");
            str = str.Replace(" ", "-");
            return str;
        }

        public static string VietnameseUnsign(string str)
        {
            //Tiến hành thay thế , lọc bỏ dấu cho chuỗi

            for (int i = 1; i < VietNamChar.Length; i++)
            {

                for (int j = 0; j < VietNamChar[i].Length; j++)

                    str = str.Replace(VietNamChar[i][j], VietNamChar[0][i - 1]);

            }

            return str;
        }

        public static bool CheckVietNamese(string str)
        {
            //Thay thế và lọc dấu từng char      
            for (int i = 1; i < VietNamChar.Length; i++)
            {
                for (int j = 0; j < VietNamChar[i].Length; j++)
                { 
                    int idx = str.IndexOf(VietNamChar[i][j]);
                    if (idx >0)
                    {
                        return true; break;
                    }
                }

            }
            return false;
        }
        public static String getModuleName(String URIInSys)
        {
            String funcName = "";
            try
            {

                int lenURIInSys = URIInSys.Trim().Length;

                if (URIInSys.IndexOf("?") != -1)
                {
                    if (URIInSys.IndexOf("module") != -1)
                    {
                        if (!URIInSys.Contains("&"))
                        {
                            int lenFunc = lenURIInSys - URIInSys.IndexOf("=") - 1;
                            funcName = URIInSys.Substring(URIInSys.IndexOf("=") + 1, lenFunc);
                        }
                        else
                        {
                            int lenFunc = URIInSys.IndexOf("&") - URIInSys.IndexOf("=") - 1;

                            funcName = URIInSys.Substring(URIInSys.IndexOf("=") + 1, lenFunc);
                        }
                    }
                    else
                    {
                        int lenFunc = URIInSys.IndexOf("?") - 1 - URIInSys.LastIndexOf("/");
                        funcName = URIInSys.Substring(URIInSys.LastIndexOf("/") + 1, lenFunc);
                    }
                }
                else
                {
                    int lenFunc = lenURIInSys - URIInSys.LastIndexOf("/") - 1;
                    funcName = URIInSys.Substring(URIInSys.LastIndexOf("/") + 1, lenFunc);
                }
                return funcName;
            }
            catch (Exception e)
            {
                return "";
               // throw e;
            }

        }

        public static void addheader(System.Web.UI.Page Page, string strTitle, string strDescription, string strkeywords,string strSiteName)
        {
           
            //<meta name="robots" content="noodp,index,follow" />
            HtmlMeta pagerobots = new HtmlMeta();
            pagerobots.Name = "robots";
            pagerobots.Content = "noodp,index,follow";
            Page.Header.Controls.Add(pagerobots);

            //<meta name="Googlebot" content="index" />
            HtmlMeta pageGooglebot = new HtmlMeta();
            pageGooglebot.Name = "Googlebot";
            pageGooglebot.Content = "index";
            Page.Header.Controls.Add(pageGooglebot);

            //<meta name="medium" content="news" />
            HtmlMeta pagemedium = new HtmlMeta();
            pagemedium.Name = "medium";
            pagemedium.Content = "news";
            Page.Header.Controls.Add(pagemedium);
            //<meta name='revisit-after' content='1 days' />
            HtmlMeta revisit = new HtmlMeta();
            revisit.Name = "revisit-after";
            revisit.Content = "1 days";
            Page.Header.Controls.Add(revisit);

          //  <meta http-equiv="content-language" content="vi" />
            HtmlMeta laguagevi = new HtmlMeta();
            laguagevi.Name = "content-language";
            laguagevi.Content = "vi";
            Page.Header.Controls.Add(laguagevi);
            //<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
            HtmlMeta http = new HtmlMeta();
            http.Name = "http-equiv";
            http.Content = "text/html; charset=utf-8";
            Page.Header.Controls.Add(http);

            //Page description
            HtmlMeta pagedesc = new HtmlMeta();
            pagedesc.Name = "Description";
            pagedesc.Content = strDescription;
            Page.Header.Controls.Add(pagedesc);

            //page keywords
            HtmlMeta pagekeywords = new HtmlMeta();
            pagekeywords.Name = "keywords";
            pagekeywords.Content = strkeywords;
            Page.Header.Controls.Add(pagekeywords);

            //Page og:title
            if (strTitle!="")
            {
                // set page title
                Page.Title = strTitle;
                HtmlMeta tagogtitle = new HtmlMeta();
                tagogtitle.Attributes.Add("property", "og:title");
                tagogtitle.Content = strTitle; // don't HtmlEncode() string. HtmlMeta already escapes characters.
                Page.Header.Controls.Add(tagogtitle);
            }
            //Page og:site_name
            HtmlMeta tagogsite_name = new HtmlMeta();
            tagogsite_name.Attributes.Add("property", "og:site_name");
            tagogsite_name.Content = strSiteName; // don't HtmlEncode() string. HtmlMeta already escapes characters.
            Page.Header.Controls.Add(tagogsite_name);
            //Page og:description
            HtmlMeta tagogdescription = new HtmlMeta();
            tagogdescription.Attributes.Add("property", "og:description");
            tagogdescription.Content = strDescription; // don't HtmlEncode() string. HtmlMeta already escapes characters.
            Page.Header.Controls.Add(tagogdescription);

            
        }
        public static DataTable AddColDataTable(string[] col)
        {
            try
            {
                DataTable dt = new DataTable();
                for (int i = 0; i < col.Length; i++)
                {
                    dt.Columns.Add(new DataColumn(col[i]));
                }
                return dt;
            }
            catch (Exception)
            {
                return null;
            }
        }
        public static DataTable ArrToDataTable(string[] arrsource, string[] col)
        {
            try
            {
                DataTable dt = new DataTable();
                dt = AddColDataTable(col);
                for (int j = 0; j < arrsource.Length; j++)
                {
                    DataRow newRow = dt.NewRow();
                    string[] arrcontent = arrsource[j].Split(new char[] { '@' }, StringSplitOptions.RemoveEmptyEntries);
                   
                    if (arrcontent.Length <col.Length)
                    {
                         int startIndexForNewArray = arrcontent.Length;
                        Array.Resize<string>(ref arrcontent, col.Length);
                        for (int i = startIndexForNewArray; i <arrcontent.Length ; i++)
                        {
                           arrcontent[i] = " ";
                        }
                    }
                    for (int k = 0; k < col.Length; k++)
                    {
                        newRow[k] = arrcontent[k];

                    }
                    dt.Rows.Add(newRow);
                }
                return dt;
            }
            catch (Exception)
            {
                return null;
            }
        }
        public static string[] getallfilexml(string name, System.Web.UI.Page Page)
        {
            try
            {
               
                string rootPath = Page.Request.PhysicalApplicationPath + name;
                DirectoryInfo info = new DirectoryInfo(rootPath);
                FileInfo[] files = info.GetFiles("*.xml*", System.IO.SearchOption.TopDirectoryOnly).OrderBy(p => p.LastWriteTime).ToArray();
                string[] arr = new string[files.Length];
                for (int i = 0; i < files.Length; i++)
                {
                    arr[files.Length-i-1] = files[i].DirectoryName + "//" + files[i].Name;
                }
                return arr;
            }
            catch (Exception)
            {
                return null;
            }
        }

        #region MVC
        public static MvcHtmlString GenHtmlcode(string strSource)
        {
            if (strSource == "")
            {
                return MvcHtmlString.Empty;
            }
            return MvcHtmlString.Create(strSource);
        }
        public static string getFileExt(string str)
        {
            string[] arrStr = str.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
            string ext = arrStr[arrStr.Length - 1];
            return ext;
        }
        #endregion
    }
}
